package com.yidu.hbatsams.service.Impl;

import com.yidu.hbatsams.dao.AtsBaseItemMapper;
import com.yidu.hbatsams.dao.AtsBaseSportItemMapper;
import com.yidu.hbatsams.domain.AtsBaseItem;
import com.yidu.hbatsams.domain.AtsBaseSportItem;
import com.yidu.hbatsams.service.AtsBaseItemService;
import com.yidu.hbatsams.utils.AtsBaseItemTree;
import com.yidu.hbatsams.utils.Tools;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class AtsBaseItemServiceImpl implements AtsBaseItemService {
    @Resource
    AtsBaseItemMapper atsBaseItemMapper ;//AtsBaseItemMapper Dao类

    @Resource
    AtsBaseSportItemMapper atsBaseSportItemMapper;//AtsBaseSportItemMapper Dao类

    /**
     * 查询所有
     * @param isva
     * @return
     */
    @Override
    public List<AtsBaseItem> findAll(Integer isva) {
         List<AtsBaseItem> list = atsBaseItemMapper.findAll(isva);//调用dao类方法
        Map<Integer , String> map = new HashMap<>() ;//map方法
        for (Iterator<AtsBaseItem> iterator = list.iterator(); iterator.hasNext(); ) {// for each
            AtsBaseItem next =  iterator.next();
            String strs = map.get(next.getParentId());//定map中的get次ID方法
            if(next.getParentId()==0){//判断是否为一级ID
                next.setParentName("该指标为一级指标");
            }else if(strs!=null){//判断次ID是否为null
                next.setParentName(strs);
            }else{
                for (Iterator<AtsBaseItem> atsBaseItemIterator = list.iterator(); atsBaseItemIterator.hasNext(); ) {//for each
                    AtsBaseItem atsBaseItem =  atsBaseItemIterator.next();
                    if(atsBaseItem.getItemId()==next.getParentId()){//判断次ID 是否相同
                        next.setParentName(atsBaseItem.getItemExp());//赋值名称
                        map.put(next.getParentId(),next.getParentName());//将次id 与次id 名称存入map中
                    }

                }
            }
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");//调用时间方法
            String str = simpleDateFormat.format(next.getCreatTime());//存入时间
            Date date = new Date();//时间方法
            try {
                date = simpleDateFormat.parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            next.setCreatTime(date);//给时间赋值
        }

        return list ;//返回list
    }

    /**
     * 根据删除数据
     * @param id
     * @return
     */
    @Override
    public int deleteByPrimaryKey(String id , Integer isva) {
        AtsBaseItem atsBaseItem = new AtsBaseItem();//AtsBaseItem方法
        atsBaseItem.setItemId(Integer.valueOf(id));//给主ID 赋值
        atsBaseItem.setIsva(0);//给状态赋值
        List<AtsBaseItem> list = atsBaseItemMapper.findAll(isva);//list调用查询所有方法
        Map<Integer,AtsBaseItem> map = new HashMap<>();//调用map方法
        for (int i = 0; i < list.size(); i++) {//for判断
            map.put(list.get(i).getItemId(),list.get(i));//将list数据存入map中
        }
        List<AtsBaseItem> listOne = atsBaseItemMapper.findByPid(Integer.valueOf(id) , isva);//根据外建查询数据
        String str = "";//定义为空
        if(listOne.size()>0){//判断list的长度
            AtsBaseItem atsBaseItem1 = new AtsBaseItem();//AtsBaseItem方法
            atsBaseItem1.setIsva(0);//给状态赋值
            for(int i = 0 ; i<listOne.size() ; i++){
                atsBaseItem1.setItemId(listOne.get(i).getItemId());
                atsBaseItemMapper.updateByPrimaryKeySelective(atsBaseItem1);
                atsBaseSportItemMapper.deleteItem(listOne.get(i).getItemId());
                str+=listOne.get(i).getItemId()+",";
            }
            for(int j = 0 ; j <1 ; j--){
                String[] chars = str.split(",");
                str = "";
                int num = 0 ;
                for(int i = 0 ; i<chars.length ; i++){
                    AtsBaseItem atsBaseItem2 = map.get(chars[i]);
                    if(atsBaseItem2.getParentId()!=0){
                        num = 1 ;
                        atsBaseItem1.setItemId(atsBaseItem2.getParentId());
                        atsBaseItemMapper.updateByPrimaryKeySelective(atsBaseItem1);
                        atsBaseSportItemMapper.deleteItem(atsBaseItem2.getParentId());
                        str+=atsBaseItem2.getParentId()+",";
                    }
                }
                if(num==0){
                    break;
                }
            }
        }
        /*atsBaseSportItemMapper.delete*/
        return atsBaseItemMapper.updateByPrimaryKeySelective(atsBaseItem);
    }

    /**下拉树
     * @return
     * 查询全部数据的
     */
    @Override
    public List<AtsBaseItemTree> findTreeNode(Integer isva,String top) {
        List<AtsBaseItem> list = atsBaseItemMapper.findAll(isva);
        if(top==null){
            AtsBaseItem atsBaseItem=new AtsBaseItem();
            atsBaseItem.setItemId(0);
            atsBaseItem.setItemExp("顶级指标");
            atsBaseItem.setParentId(0);
            list.add(atsBaseItem);
        }
        List<AtsBaseItemTree> listTree = new ArrayList<>();
        for (Iterator<AtsBaseItem> iterator = list.iterator(); iterator.hasNext(); ) {
            AtsBaseItem next =  iterator.next();
            AtsBaseItemTree AtsBaseItemTree = new AtsBaseItemTree();
            AtsBaseItemTree.setId(String.valueOf(next.getItemId()));
            AtsBaseItemTree.setValue(String.valueOf(next.getParentId()));
            AtsBaseItemTree.setTitle(next.getItemExp());
            AtsBaseItemTree.setField(next.getItemExp());
            AtsBaseItemTree.setLabel(next.getItemExp());
            AtsBaseItemTree.setDisabled(false);

            listTree.add(AtsBaseItemTree);

        }
        List<AtsBaseItemTree> listAtsBaseItemTree = createTree(listTree);

        return listAtsBaseItemTree;
    }


    /**
     * 查询全部数据的下拉树
     * @return
     */
    @Override
    public List<AtsBaseItemTree> treeNode(Integer isva,String top, Integer curriculumId) {
        List<AtsBaseItem> list = atsBaseItemMapper.findSort(isva);
        Map<Integer,AtsBaseItem> map = new HashMap<>();
        for (int i = 0; i < list.size(); i++) {
            map.put(list.get(i).getItemId(),list.get(i));
        }
        if(top==null){
            AtsBaseItem atsBaseItem=new AtsBaseItem();
            atsBaseItem.setItemId(0);
            atsBaseItem.setItemExp("顶级指标");
            atsBaseItem.setParentId(0);
            list.add(atsBaseItem);
        }
        List<AtsBaseItemTree> listTree = new ArrayList<>();
        List<AtsBaseItem> listPlan = new ArrayList<>();
        if(curriculumId!=null){
            listPlan = atsBaseItemMapper.findPlan(curriculumId);
        }
        for (Iterator<AtsBaseItem> iterator = list.iterator(); iterator.hasNext(); ) {
            AtsBaseItem next =  iterator.next();
            AtsBaseItemTree AtsBaseItemTree = new AtsBaseItemTree();
            AtsBaseItemTree.setId(String.valueOf(next.getItemId()));
            AtsBaseItemTree.setValue(String.valueOf(next.getParentId()));
            if(next.getParentId()!=0){
                //通过外键id得到值
                AtsBaseItem atsBaseItem = map.get(next.getParentId());
                //将名字传给name
                AtsBaseItemTree.setName(atsBaseItem.getItemExp());
            }

            AtsBaseItemTree.setTitle(next.getItemExp());
            AtsBaseItemTree.setField(next.getItemExp());
            AtsBaseItemTree.setLabel(next.getItemExp());
            AtsBaseItemTree.setDisabled(false);
            for (int i = 0; i <listPlan.size() ; i++) {
                if(next.getItemId().equals(listPlan.get(i).getSort())){
                    AtsBaseItemTree.setChecked(true);
                    break ;
                }else{
                    AtsBaseItemTree.setChecked(false);
                }
            }
            listTree.add(AtsBaseItemTree);

        }
        List<AtsBaseItemTree> listAtsBaseItemTree = createTree(listTree);

        return listAtsBaseItemTree;
    }

    @Override
    public List<AtsBaseItem> selectjs(Integer isva) {
        List<AtsBaseItem> list = atsBaseItemMapper.selectjs(isva);
        Map<Integer , String> map = new HashMap<>() ;
        for (Iterator<AtsBaseItem> iterator = list.iterator(); iterator.hasNext(); ) {
            AtsBaseItem next =  iterator.next();
            String strs = map.get(next.getParentId());
            if(next.getParentId()==0){
                next.setParentName("该指标为一级指标");
            }else if(strs!=null){
                next.setParentName(strs);
            }else{
                for (Iterator<AtsBaseItem> atsBaseItemIterator = list.iterator(); atsBaseItemIterator.hasNext(); ) {
                    AtsBaseItem atsBaseItem =  atsBaseItemIterator.next();
                    if(atsBaseItem.getItemId()==next.getParentId()){
                        next.setParentName(atsBaseItem.getItemExp());
                        map.put(next.getParentId(),next.getParentName());
                    }

                }
            }
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
            String str = simpleDateFormat.format(next.getCreatTime());
            Date date = new Date();
            try {
                date = simpleDateFormat.parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            next.setCreatTime(date);
        }

        return list ;
    }

    /**
     * 增加数据
     * @param atsBaseItem 指标实体类
     * @return 返回一个int类型数字
     */
    @Override
    public int insert(AtsBaseItem atsBaseItem) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        int num = 0 ;
        for (int i = 0 ; i < 1 ; i--){
            num = Tools.getRandomNumber(2147483647);
            AtsBaseItem atsBaseItem1 = atsBaseItemMapper.selectByPrimaryKey(num);
            if(atsBaseItem1==null){
                break ;
            }
        }
        atsBaseItem.setItemId(num);
        String str = df.format(new Date());
        Date date = null ;
        try {
            date = df.parse(str);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        if(atsBaseItem.getParentId()==0){
            atsBaseItem.setItemLevel("1");
        }else{
            AtsBaseItem atsBaseItem1 = atsBaseItemMapper.selectByPrimaryKey(atsBaseItem.getParentId());
            atsBaseItem.setItemLevel(String.valueOf(Integer.valueOf(atsBaseItem1.getItemLevel())+1));
        }

        atsBaseItem.setCreatTime(date);
        if(atsBaseItem.getItemUnit()==null || atsBaseItem.getItemUnit().equals("")){
            atsBaseItem.setItemUnit("无单位");
        }
        if(atsBaseItem.getRemark()==null || atsBaseItem.getRemark().equals("")){
            atsBaseItem.setRemark("无备注");
        }
        if(atsBaseItem.getSport()!=null && !"".equals(atsBaseItem.getSport())){
            String[] strse = atsBaseItem.getSport().split(",");
            for (int i = 0 ; i <strse.length ; i++){
                AtsBaseSportItem atsBaseSportItem = new AtsBaseSportItem() ;
                atsBaseSportItem.setItemId(atsBaseItem.getItemId());
                atsBaseSportItem.setSportId(Integer.valueOf(strse[i]));
                atsBaseSportItem.setIsva(1);
                atsBaseSportItemMapper.insertSelective(atsBaseSportItem);
                int pid = atsBaseItem.getParentId() ;
                for (int y = 0 ; y<1 ; y--){
                    if(pid==0){
                        break ;
                    }else{
                        AtsBaseItem atsBaseItem1 = atsBaseItemMapper.selectByPrimaryKey(pid);
                        atsBaseSportItem.setItemId(atsBaseItem1.getItemId());
                        List<AtsBaseSportItem> list1 = atsBaseSportItemMapper.selectItemSport(atsBaseItem1.getItemId(),Integer.valueOf(strse[i]));
                        if(list1.size()==0){
                            atsBaseSportItemMapper.insertSelective(atsBaseSportItem);
                        }
                        pid = atsBaseItem1.getParentId();
                    }
                }
            }
        }
        return atsBaseItemMapper.insertSelective(atsBaseItem);
    }
    /**
     * 根据id查询数据
     * @param id
     * @return 返回一个指标类
     */
    @Override
    public AtsBaseItem findById(String id) {
        return atsBaseItemMapper.selectByPrimaryKey(Integer.valueOf(id));
    }

    /**
     * 修改数据
     * @param atsBaseItem 指标实体类
     * @return 返回一个数字
     */
    @Override
    public int update(AtsBaseItem atsBaseItem) {
        AtsBaseItem atsBaseItem12 = atsBaseItemMapper.selectByPrimaryKey(atsBaseItem.getItemId());
        atsBaseItem.setCreater(atsBaseItem12.getCreater());
        atsBaseItem.setCreatTime(atsBaseItem12.getCreatTime());
        atsBaseItem.setIsva(atsBaseItem12.getIsva());
        atsBaseItem.setSort(atsBaseItem12.getSort());
        if(atsBaseItem.getParentId()==0){
            atsBaseItem.setParentId(0);
            atsBaseItem.setItemLevel("1");
        }else {

            AtsBaseItem atsBaseItem2 = atsBaseItemMapper.selectByPrimaryKey(atsBaseItem.getParentId());
            atsBaseItem.setItemLevel(String.valueOf(Integer.valueOf(atsBaseItem2.getItemLevel()) + 1));
        }
        atsBaseSportItemMapper.deleteItem(atsBaseItem.getItemId());
        if(atsBaseItem.getSport()!=null && !"".equals(atsBaseItem.getSport())){
            List<AtsBaseItem> listItem = atsBaseItemMapper.findAll(atsBaseItem.getIsva());
            Map<Integer,AtsBaseItem> mapItem = new HashMap<>();
            for(int i = 0 ; i<listItem.size() ; i++){
                mapItem.put(listItem.get(i).getItemId(),listItem.get(i));
            }

            String[] strse = atsBaseItem.getSport().split(",");
            for (int i = 0 ; i <strse.length ; i++){
                AtsBaseSportItem atsBaseSportItem = new AtsBaseSportItem() ;
                atsBaseSportItem.setItemId(atsBaseItem.getItemId());
                atsBaseSportItem.setSportId(Integer.valueOf(strse[i]));
                atsBaseSportItem.setIsva(1);
                atsBaseSportItemMapper.insertSelective(atsBaseSportItem);
                int pid = atsBaseItem.getParentId() ;
                List<AtsBaseSportItem> listAts = atsBaseSportItemMapper.selectALLs();
                Map<String,AtsBaseSportItem> map = new HashMap<>();
                for(int j = 0 ; j<listAts.size() ; j++){
                    map.put(listAts.get(j).getItemId()+","+listAts.get(j).getSportId(),listAts.get(j));
                }
                for (int y = 0 ; y<1 ; y--){
                    if(pid==0){
                        break ;
                    }else{
                        AtsBaseItem atsBaseItem1 = mapItem.get(pid);
                        atsBaseSportItem.setItemId(atsBaseItem1.getItemId());

                        AtsBaseSportItem atsBaseSportItem1 = map.get(pid+","+Integer.valueOf(strse[i]));
                        if(atsBaseSportItem1==null){
                            atsBaseSportItemMapper.insertSelective(atsBaseSportItem);
                        }
                        pid = atsBaseItem1.getParentId();
                    }
                }

            }
            List<AtsBaseSportItem> listAts = atsBaseSportItemMapper.selectALLs();
            Map<String,AtsBaseSportItem> map = new HashMap<>();
            for(int j = 0 ; j<listAts.size() ; j++){
                map.put(listAts.get(j).getItemId()+","+listAts.get(j).getSportId(),listAts.get(j));
            }
            List<AtsBaseItem> listOne = atsBaseItemMapper.findByPid(atsBaseItem.getItemId(),atsBaseItem.getIsva());
            if(listOne.size()>0){
                String sun = "";
                for (int j = 0; j <listOne.size() ; j++) {
                    List<AtsBaseSportItem> listTwo = atsBaseSportItemMapper.selectItme(listOne.get(j).getItemId());
                    for (int k = 0; k < listTwo.size() ; k++) {
                        int sus = sun.indexOf(listTwo.get(k).getSportId());
                        if(sus==-1){
                            AtsBaseSportItem atsBaseSportItem = map.get(atsBaseItem.getItemId()+","+listTwo.get(k).getSportId());
                            if(atsBaseSportItem==null){
                                AtsBaseSportItem atsBaseSportItem1 = new AtsBaseSportItem();
                                atsBaseSportItem1.setIsva(1);
                                atsBaseSportItem1.setItemId(atsBaseItem.getItemId());
                                atsBaseSportItem1.setSportId(listTwo.get(k).getSportId());
/*
                                atsBaseSportItemMapper.deleteItemSport(atsBaseItem.getItemId(),listTwo.get(k).getSportId());
*/
                                atsBaseSportItemMapper.insertSelective(atsBaseSportItem1);
                                sun+=listTwo.get(k).getSportId()+",";
                            }
                        }
                    }
                }
            }
        }
        return atsBaseItemMapper.updateByPrimaryKeySelective(atsBaseItem);
    }
    /**
     * 下拉树
     * @param nodes
     * @return
     */
    public List<AtsBaseItemTree> createTree(List<AtsBaseItemTree> nodes) {
        if (nodes == null || nodes.size() < 0){
            return null;
        }
        List<AtsBaseItemTree> nodeList = new ArrayList<>();// 根节点自定义，但是要和pid对应好
        // 将所有节点添加到多叉树中
        for (AtsBaseItemTree node : nodes) {
            if (node.getValue().equals("0")) {// 根节点自定义，但是要和pid对应好
                // 向根添加一个节点
                nodeList.add(node);
            } else {
                for (AtsBaseItemTree item : nodes) {
                    if (item.getId().equals(node.getValue())) {
                        item.getChildren().add(node);
                        item.setData(item.getChildren());
                        break ;
                    }
                }
            }
        }
        return nodeList;
    }

    /**
     * 关联查询指标外键等于0的数据
     * @param sportId
     * @return
     */
    @Override
    public List<AtsBaseItem> findItemSport(Integer parentId , Integer sportId) {

        return atsBaseItemMapper.findItemSport(parentId , sportId);
    }
    /**
     * 根据课计划id查询指标
     * @param pid 课计划id
     * @return
     */
    @Override
    public List<AtsBaseItemTree> findPlanItem(Integer pid) {
        List<AtsBaseItem> list1 = atsBaseItemMapper.findAll(2);
        Map<Integer,AtsBaseItem> map = new HashMap<>();
        for (int i = 0; i < list1.size(); i++) {
            map.put(list1.get(i).getItemId(),list1.get(i));
        }
        List<AtsBaseItem> list = atsBaseItemMapper.findPlanItem(pid);
        List<AtsBaseItemTree> list2 = new ArrayList<>();
        for (int i = 0; i < list.size() ; i++) {
            AtsBaseItemTree atsBaseItemTree = new AtsBaseItemTree();
            atsBaseItemTree.setId(String.valueOf(list.get(i).getItemId()));
            atsBaseItemTree.setField(String.valueOf(list.get(i).getItemExp()));
            AtsBaseItem atsBaseItem = map.get(list.get(i).getItemId());
            AtsBaseItem atsBaseItem1 = map.get(atsBaseItem.getParentId());
            atsBaseItemTree.setName(atsBaseItem1.getItemExp());
            atsBaseItemTree.setTitle(String.valueOf(list.get(i).getItemExp()));
            atsBaseItemTree.setLabel(String.valueOf(list.get(i).getItemExp()));
            list2.add(atsBaseItemTree);
        }

        return list2 ;
    }
    @Override
    public List<AtsBaseItemTree> findPlan(Integer pid) {
        List<AtsBaseItem> list = atsBaseItemMapper.findPlan(pid);
        List<AtsBaseItemTree> list1 = new ArrayList<>();
        for (int i = 0; i < list.size() ; i++) {
            AtsBaseItemTree atsBaseItemTree = new AtsBaseItemTree();
            atsBaseItemTree.setId(String.valueOf(list.get(i).getSort()));
            atsBaseItemTree.setField(String.valueOf(list.get(i).getItemId()));
            atsBaseItemTree.setName(String.valueOf(list.get(i).getItemUnit()));
            atsBaseItemTree.setTitle(String.valueOf(list.get(i).getItemExp()));
            atsBaseItemTree.setLabel(String.valueOf(list.get(i).getIsva()));
            list1.add(atsBaseItemTree);
        }

        return list1 ;
    }

    /**
     * 根据运动项目查询指标
     * @param sport
     * @param isva
     * @return
     */
    @Override
    public List<AtsBaseItemTree> findSport(String sport, String isva , Integer curriculumId) {
        List<AtsBaseItem> list = atsBaseItemMapper.findSport(Integer.valueOf(sport),Integer.valueOf(isva));
        List<AtsBaseItemTree> listTree = new ArrayList<>();
        List<AtsBaseItem> listPlan = new ArrayList<>();
        if(curriculumId!=null){
            listPlan = atsBaseItemMapper.findPlan(curriculumId);
        }
        for (int i = 0; i < list.size(); i++) {
            AtsBaseItemTree atsBaseItemTree = new AtsBaseItemTree();
            atsBaseItemTree.setId(String.valueOf(list.get(i).getItemId()));
            atsBaseItemTree.setField(String.valueOf(list.get(i).getItemId()));
            atsBaseItemTree.setValue(String.valueOf(list.get(i).getParentId()));
            atsBaseItemTree.setName(list.get(i).getItemExp());
            atsBaseItemTree.setTitle(list.get(i).getItemExp());
            for (int z = 0; z <listPlan.size() ; z++) {
                if(list.get(i).getItemId().equals(listPlan.get(z).getSort())){
                    atsBaseItemTree.setChecked(true);
                    break ;
                }else{
                    atsBaseItemTree.setChecked(false);
                }
            }
            atsBaseItemTree.setLabel(list.get(i).getItemExp());
            listTree.add(atsBaseItemTree);

        }
        List<AtsBaseItemTree> listAtsBaseItemTree = createTree(listTree);
        return listAtsBaseItemTree;
    }
}
